/**
 * 向本节点添加一个子节点 JDian
 * @参数 {对象}  被添加的子节点  JDian
 */
NW02_jd.prototype.tjEZ = function (JD) {
    if (JD) {
        let _Erzi = this.wgj.hqJD(JD);
        if (_Erzi) {
            this.Jiedian.appendChild(_Erzi);// 将两个节点，变成父子(fuZi)关系
        }
    }
}

/**
 * 创建一个子节点
 * @参数 {文本} ysBQ 节点标签。如果没有指明标签符号，默认是 div
 * @返回 {对象} 子节点
 */
NW02_jd.prototype.cjEZ = function (ysBQ, SXdx) {
    let _Erzi = this.wgj.cjJiedian(ysBQ, SXdx);//创建一个节点
    this.Jiedian.appendChild(_Erzi);// 将两个节点，变成父子(fuZi)关系
    return _Erzi;
}

/**
 * 创建一个子节点_下拉列表（复选框）
 * 
 * @参数 {数组} xxS 选项列表 对象 数组;  数组[{ming:'xxxxxx' ,zhi:'ssssss'}]
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW02_jd.prototype.cjEZ_xllb = function (xxS, morenzhi, SXdx) {
    // let _Erzi = this.cjJiedian(ysBQ, SXdx);//创建一个节点
    let _Erzi = this.wgj.cjJiedian_select(xxS, morenzhi, SXdx);
    this.Jiedian.appendChild(_Erzi);// 将两个节点，变成父子(fuZi)关系
    return _Erzi;
}

/**
 * 删除一个子节点
 * @参数 {正数|文本|对象} yb_Id_erzi 子节点或其id或其在所有的儿子们中，排的顺序（从0开始算，不计文本节点）
 */
NW02_jd.prototype.scEZ = function (yb_Id_erzi) {
    if (!yb_Id_erzi) {
        return;
    }
    switch (typeof yb_Id_erzi) {
        case 'object':
            this.Jiedian.removeChild(yb_Id_erzi);
            break;
        case 'number':
            this.Jiedian.removeChild(this.hqEZ_tgYB(yb_Id_erzi));
            break;
        case 'string':
            this.Jiedian.removeChild(this.wgj.hqJD(yb_Id_erzi));
            break;
    }
}

/**
 * 通过 【子节点游标】，直接找到子节点。不包含文本节点
 * @参数 {对象} yb 子节点 游标（在所在儿子们那里，它排在第几位——从0开始算）
 * @返回 {对象} 子节点
 */
NW02_jd.prototype.hqEZ_tgYB = function (yb) {
    let _ErziM = this.hqEZm_feiWB(); //不包含文本节点的 子节点集合
    if (_ErziM.length == 0) {
        return null;
    }
    for (let i = 0; i < _ErziM.length; i++) {
        if (i == yb) {
            return _ErziM[i];
        }
    }
    return null;

}

/**
 * 取得子节点Erzi 在本节点的子节点集合中,它的顺序.
 * 备注:不包含[文本节点]
 * 
 * @参数 {对象} Erzi 普通\nw节点，子节点
 * 
 * @返回 {int} Erzi在父类的子节点集合的游标 .
 */
NW02_jd.prototype.hqEZyb = function (Erzi) {
    if (!Erzi) { //如果不为真值,直接返回-1
        return -1;
    }
    let _Ez = Erzi.Jiedian ? Erzi.Jiedian : Erzi;
    let _ErziM = this.hqEZm_feiWB(); //取得所有非文本的子节点
    if (_ErziM.length == 0) {
        return -1;
    }
    for (let i = 0; i < _ErziM.length; i++) {
        if (_ErziM[i] == _Ez) {
            return i;
        }
    }
    return -1;
}

/**
 * 获取(hq)节点的所有儿子(不算文本节点在内)
 * 
 * @返回 {数组} 节点的儿子们
 */
NW02_jd.prototype.hqEZm_feiWB = function () {
    return this.Jiedian.children;
}

/**
 * 获取(hq)节点的所有儿子
 * 
 * @返回 {数组} 节点的儿子们
 */
NW02_jd.prototype.hqEZm = function () {
    return this.Jiedian.childNodes;
}

/**
 * 节点移动
 * 正数右移,负数左移.
 * 假设数组[a,b,1,2,3],参数Erzi="b",数组下标=1
 * 假设shunXu=2   ,b向右移动2个格子,移动后的数组:[a,1,2,b,3]
 * 假设shunXu=-1  ,b向左移动1个格子.移动后的数组:[b,a,1,2,3]
 * 
 * @参数 {对象} Erzi 子节点
 * @参数 {对象} shunXu 正数,表示离0位越远_向右移到shunXu格子;负数,表示离0位越近,向左移
 */
NW02_jd.prototype.ydEZ_tgSX = function (Erzi, shunXu) {
    if (!Erzi || shunXu == 0) {
        return;
    }
    let _EZ = this.wgj.hqJD(Erzi);
    if (!_EZ) {
        return;
    }
    let _ErziM = this.hqEZm_feiWB();
    let _yb = this.hqEZyb(_EZ); //取得son的下标.
    if (_yb == null) {
        return; //末知的坐标.假值 
    }
    let sonArr = []; //临时数组
    let sonArrIndex = 0; //sonArr的临时下标 .
    //右移
    if (shunXu > 0) {
        //1假设son原本位置在1,shunXu=2; 那么,移后的位置应该是 1+2=3;
        _yb = _yb + shunXu;
        //2假设数组最大下标为2;如[a,son,b],那么,下标3已经超出我们的数组的范围.
        if (_yb > _ErziM.length - 1) { // sons.length - 1 就是假定数组的 最大下标.
            _yb = _ErziM.length - 1; //数组的长度3,下标最大限制值是2 因为,下标是从0开始计算.
        }
    } else { //进入else,条件必定是:shunXu < 0   左移
        //假设数组[a,b,c,son,d,e]
        //1假设son原本位置在3,shunXu=-2; 那么,移后的位置应该是 3+(-2)=1;
        _yb = _yb + shunXu; //假设shunXu=-4时,很明显,3+(-4)=-1!明显超出数组的范围.所以
        if (_yb < 0) { //如果超出顶部位置,锁定其位置为0;
            _yb = 0;
        }
    }
    sonArr[_yb] = _EZ; //排好son的新位置
    // console.log('son=' + son['id'] + '计算后的位置是:' + index);
    //排序.
    for (let i = 0; i < _ErziM.length; i++) {
        if (_ErziM[i] == _EZ) {
            continue; //son已经放到 sonArr[index]中去了.
        }
        if (_yb == sonArrIndex) { //如果数组已经有值,下标 下移一位.
            sonArrIndex++;
        }
        sonArr[sonArrIndex++] = _ErziM[i];
    }
    //按排序好的顺序,不断追加到父节点.如果父节点已经有这个子节点,会自动删除后,再追加
    for (let i = 0; i < sonArr.length; i++) {
        this.tjEZ(sonArr[i]);
    }
    sonArr.length = 0; //数组回收
    return;
}

// 'name=wang'
NW02_jd.prototype.hqEZ_tgTJ = function () {

}